import { _decorator, Component, Node, ScrollView, instantiate, Prefab} from 'cc';
import { PlayerStats } from './PlayerStats';
import { PlayerStatsManager } from './PlayerStatsManager';
import { BattleResultData, IndexEntityStatsItemData } from '../../../battle/Model';
import { EntityInfoItemController } from './EntityInfoItemController';
import { LOG } from '../../../ConsoleLogCtrl';
const { ccclass, property } = _decorator;

/**
 * 实体统计面板组件
 * 用于显示玩家所有实体（单位和建筑）的详细信息
 */
@ccclass('EntityStatsPanel')
export class EntityStatsPanel extends Component {
    @property(ScrollView)
    public scrollView: ScrollView = null;

    @property(Node)
    public contentNode: Node = null;

    @property(Prefab)
    public statItemTemplate: Prefab = null;

    @property(Prefab)
    public entityStatsItemPrefab: Prefab = null;

    @property
    public autoUpdate: boolean = true;

    // 是否显示面板
    private _isVisible: boolean = false;

    // 自动更新定时器
    private _updateTimer: number = null;

    // 当前显示的玩家ID
    private _currentPlayerId: string = null;

    // 统计项目节点缓存
    private _statItems: Map<string, Node> = new Map();

    // 战斗结果数据
    private _battleResult: BattleResultData = null;

    onLoad() {
        this.initComponents();
        this.hidePanel(); // 默认隐藏面板
    }

    start() {
        if (this.autoUpdate) {
            this.startAutoUpdate();
        }
    }

    /**
     * 初始化组件
     */
    private initComponents() {
        // 初始化内容节点
        if (!this.contentNode && this.scrollView) {
            this.contentNode = this.scrollView.content;
        }

    }

    /**
     * 显示面板
     */
    public showPanel() {
        this.node.active = true;
        this._isVisible = true;
        // 更新统计数据
        this.updateEntityStats();

        // 如果有保存的战斗结果，停止自动更新
        if (this._battleResult) {
            this.stopAutoUpdate();
        } else {
            // 只有在没有战斗结果时才启动自动更新
            if (this.autoUpdate) {
                this.startAutoUpdate();
            }
        }
    }

    /**
     * 隐藏面板
     */
    public hidePanel() {
        this.node.active = false;
        this._isVisible = false;
        // 停止自动更新
        this.stopAutoUpdate();

    }

    /**
     * 开始自动更新
     */
    public startAutoUpdate() {
        // 先停止现有的定时器，避免重复启动
        this.stopAutoUpdate();

        // 每秒更新一次
        this._updateTimer = setInterval(() => {
            if (this._isVisible) {
                this.updateEntityStats();
            }
        }, 1000);
    }

    /**
     * 停止自动更新
     */
    public stopAutoUpdate() {
        if (this._updateTimer) {
            // 停止前再刷一次
            this.updateEntityStats();
            clearInterval(this._updateTimer);
            this._updateTimer = null;
        }
    }

    /**
     * 设置当前显示的玩家ID
     */
    public setCurrentPlayer(playerId: string) {
        this._currentPlayerId = playerId;
        this.updateEntityStats();
    }

    /**
     * 更新实体统计数据显示
     */
    public updateEntityStats() {
        if (!this._isVisible || !this.contentNode) return;

        // 获取玩家统计数据管理器
        const statsManager = PlayerStatsManager.getInstance();
        if (!statsManager) {
            LOG.error('无法获取PlayerStatsManager实例');
            return;
        }

        // 如果指定了当前玩家ID，只显示该玩家的统计数据
        if (this._currentPlayerId) {
            const playerStats = statsManager.getPlayerStats(this._currentPlayerId);
            if (playerStats) {
                this.displayEntityStats(playerStats);
            }
        } else {
            // 否则显示所有玩家的统计数据
            const allPlayerStats = statsManager.getAllPlayerStats();
            allPlayerStats.forEach(stats => {
                this.displayEntityStats(stats);
            });
        }
    }

    /**
     * 显示玩家实体统计数据
     */
    private displayEntityStats(playerStats: PlayerStats) {
        if (!this.contentNode) return;
        this.createStatItem(playerStats);
    }

    /**
     * 创建统计项目（用于标题和分隔线）
     */
    private createStatItem(playerStats: PlayerStats) {
        if (!this.contentNode) return null;

        // 检查是否已存在该玩家的统计项
        const key = playerStats.getId();
        let statItem = this._statItems.get(key);

        if (statItem) {
            // 如果存在,更新数据
            const itemController = statItem.getComponent(EntityInfoItemController);
            if (itemController) {
                itemController.initData(playerStats);
                itemController.setTileText(playerStats);
            }
        } else {
            // 如果不存在,创建新的统计项
            statItem = instantiate(this.statItemTemplate);
            const itemController = statItem.getComponent(EntityInfoItemController);
            if (itemController) {
                itemController.initData(playerStats);
                itemController.setTileText(playerStats);
                itemController.showContent();
            }
            // 添加到内容节点
            statItem.parent = this.contentNode;
            // 缓存节点
            this._statItems.set(key, statItem);
        }
        return statItem;
    }


    /**
     * 清空统计数据显示
     */
    public clearStats() {
        if (!this.contentNode) return;
        // 清空缓存
        //this._statItems.clear();
        for (const key in this._statItems) {
            const statItem = this._statItems[key];
            if (statItem) {
                 const itemController = statItem.getComponent(EntityInfoItemController);
                 itemController.hideContent();
            }
        }
        // 移除所有子节点
        //this.contentNode.removeAllChildren();
    }


    /**
     * 设置战斗结果
     * @param battleResult 战斗结果数据
     */
    public setBattleResult(battleResult: BattleResultData) {
        // 保存战斗结果数据
        this._battleResult = battleResult;

        // 停止自动更新
        this.stopAutoUpdate();
    }

    /**
     * 重播开始时调用，重新启动自动更新
     */
    public onReplayStart() {
        // 清除战斗结果数据
        this._battleResult = null;

        // 重播开始时重新启动自动更新
        if (this.autoUpdate && this._isVisible) {
            this.startAutoUpdate();
        }
    }

    onDestroy() {
        // 停止自动更新
        this.stopAutoUpdate();

        LOG.log('EntityStatsPanel: 组件已销毁');
    }

    /**
     * 处理高亮实体统计项的事件
     * @param eventData 事件数据
     */
    public onHighlightEntityStatsItem(eventData: IndexEntityStatsItemData): void {
        if (!eventData || !eventData.entityId) return;

        // 显示面板（如果当前是隐藏状态）
        if (!this._isVisible) {
            this.showPanel();
        }

        this._currentPlayerId = eventData.playerID;

        // 更新统计数据
        this.updateEntityStats();

        // 查找并高亮显示对应的EntityStatsItem
        this.highlightEntityStatsItemById(eventData);
    }

    /**
     * 根据ID高亮显示实体统计项
     * @param entityId 实体ID
     * @param entityType 实体类型
     */
    public highlightEntityStatsItemById(eventData: IndexEntityStatsItemData): void {
        if (!this.contentNode) return;

        // 遍历所有统计项，查找匹配的实体ID
        this._statItems.forEach((statItemNode, key) => {
            const itemController = statItemNode.getComponent(EntityInfoItemController);
            if (itemController.getPlayerType() === eventData.playerType) {
                // 设置当前显示的实体类型
                itemController.setCurrentEntityType(eventData.entityType);
                // 展开统计项
                itemController.showContent();
                // 高亮显示找到的项
                itemController.scrollToEntityStatsItem(eventData.entityId);
                itemController.highlightEntityStatsItemNode(eventData.entityId);
            }else{
                itemController.hideContent();
            }
        });
    }

}